home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1997 December / PC Pro December 1997 CD-Rom coverdisc.iso / symantec / dbAnywh / JAVA.BIN / CLASSES.ZIP / sun / tools / javadoc / DocumentationGenerator.class (.txt) next >
Encoding:
Java Class File  |  1996-12-14  |  16.8 KB  |  896 lines
  1. package sun.tools.javadoc;
  2.  
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.PrintStream;
  8. import java.util.Enumeration;
  9. import java.util.Hashtable;
  10. import java.util.StringTokenizer;
  11. import java.util.Vector;
  12. import sun.tools.java.ClassDeclaration;
  13. import sun.tools.java.ClassDefinition;
  14. import sun.tools.java.ClassNotFound;
  15. import sun.tools.java.Constants;
  16. import sun.tools.java.FieldDefinition;
  17. import sun.tools.java.Identifier;
  18. import sun.tools.java.Type;
  19. import sun.tools.javac.BatchEnvironment;
  20. import sun.tools.javac.SourceClass;
  21.  
  22. abstract class DocumentationGenerator implements Constants {
  23.    BatchEnvironment env;
  24.    private static final Identifier idIOException = Identifier.lookup("java.io.IOException");
  25.    static ClassDeclaration exDecl;
  26.    static ClassDeclaration errorDecl;
  27.  
  28.    public DocumentationGenerator init() {
  29.       this.env = Main.env;
  30.       return this;
  31.    }
  32.  
  33.    static boolean shouldDocument(ClassDefinition var0) {
  34.       return var0.isPublic();
  35.    }
  36.  
  37.    static boolean shouldDocument(FieldDefinition var0) {
  38.       return var0.isPublic() || var0.isProtected();
  39.    }
  40.  
  41.    static Vector allVariables(ClassDefinition var0) {
  42.       Vector var1 = new Vector();
  43.  
  44.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  45.          if (var2.isVariable() && shouldDocument(var2)) {
  46.             var1.addElement(var2);
  47.          }
  48.       }
  49.  
  50.       return var1;
  51.    }
  52.  
  53.    static Vector allConstructors(ClassDefinition var0) {
  54.       Vector var1 = new Vector();
  55.  
  56.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  57.          if (var2.isConstructor() && shouldDocument(var2)) {
  58.             var1.addElement(var2);
  59.          }
  60.       }
  61.  
  62.       return var1;
  63.    }
  64.  
  65.    static Vector allMethods(ClassDefinition var0) {
  66.       Vector var1 = new Vector();
  67.  
  68.       for(FieldDefinition var2 = var0.getFirstField(); var2 != null; var2 = var2.getNextField()) {
  69.          if (var2.isMethod() && !var2.isConstructor() && shouldDocument(var2)) {
  70.             var1.addElement(var2);
  71.          }
  72.       }
  73.  
  74.       return var1;
  75.    }
  76.  
  77.    static Vector localFieldsOf(ClassDefinition var0, Vector var1) {
  78.       Vector var2 = new Vector();
  79.       Enumeration var3 = var1.elements();
  80.  
  81.       while(var3.hasMoreElements()) {
  82.          FieldDefinition var4 = (FieldDefinition)var3.nextElement();
  83.          if (var4.getClassDefinition().equals(var0) && var4.getClassDeclaration() == var4.getDefiningClassDeclaration()) {
  84.             var2.addElement(var4);
  85.          }
  86.       }
  87.  
  88.       return var2;
  89.    }
  90.  
  91.    Vector superclassesOf(ClassDeclaration var1) {
  92.       if (var1 == null) {
  93.          return new Vector();
  94.       } else {
  95.          try {
  96.             ClassDeclaration var2 = var1.getClassDefinition(this.env).getSuperClass();
  97.             Vector var3 = this.superclassesOf(var2);
  98.             var3.addElement(var1);
  99.             return var3;
  100.          } catch (ClassNotFound var4) {
  101.             System.err.println("Warning: Couldn't find superclass info for " + var1.getName());
  102.             return new Vector();
  103.          }
  104.       }
  105.    }
  106.  
  107.    static Vector mergeDoc(String var0) {
  108.       Vector var1 = new Vector();
  109.       StringTokenizer var2 = new StringTokenizer(var0, "\n");
  110.  
  111.       while(var2.hasMoreTokens()) {
  112.          String var3 = var2.nextToken();
  113.          if (var3.trim().length() != 0) {
  114.             if (var3.charAt(0) == '@') {
  115.                var1.addElement(var3);
  116.             } else if (var1.size() == 0) {
  117.                var1.addElement("@comment " + var3);
  118.             } else {
  119.                int var4 = var1.size() - 1;
  120.                var1.setElementAt(var1.elementAt(var4) + "\n" + var3, var4);
  121.             }
  122.          }
  123.       }
  124.  
  125.       return var1;
  126.    }
  127.  
  128.    abstract String commentString(String var1);
  129.  
  130.    abstract String returnString(String var1);
  131.  
  132.    abstract String versionString(String var1);
  133.  
  134.    abstract String authorString(String var1);
  135.  
  136.    String getComment(Vector var1) {
  137.       Enumeration var2 = var1.elements();
  138.  
  139.       while(var2.hasMoreElements()) {
  140.          String var3 = (String)var2.nextElement();
  141.          if (var3.startsWith("@comment")) {
  142.             return this.commentString(var3.substring(8).trim());
  143.          }
  144.       }
  145.  
  146.       return null;
  147.    }
  148.  
  149.    String getReturn(Vector var1) {
  150.       String var2 = null;
  151.       Enumeration var3 = var1.elements();
  152.  
  153.       while(var3.hasMoreElements()) {
  154.          String var4 = (String)var3.nextElement();
  155.          if (var4.startsWith("@return")) {
  156.             var4 = var4.substring(7).trim();
  157.             if (var4.length() == 0) {
  158.                System.out.println("warning: empty @return statement.");
  159.             } else if (var2 == null) {
  160.                var2 = this.returnString(var4);
  161.             } else {
  162.                System.out.println("warning: multiple @return statements.");
  163.             }
  164.          }
  165.       }
  166.  
  167.       return var2;
  168.    }
  169.  
  170.    String getVersion(Vector var1) {
  171.       if (!Main.showVersion) {
  172.          return null;
  173.       } else {
  174.          String var2 = null;
  175.          Enumeration var3 = var1.elements();
  176.  
  177.          while(var3.hasMoreElements()) {
  178.             String var4 = (String)var3.nextElement();
  179.             if (var4.startsWith("@version")) {
  180.                var4 = var4.substring(8).trim();
  181.                if (var4.length() == 0) {
  182.                   System.out.println("warning: empty @version statement.");
  183.                } else if (var2 == null) {
  184.                   var2 = this.versionString(var4);
  185.                } else {
  186.                   System.out.println("warning: multiple @version statements.");
  187.                }
  188.             }
  189.          }
  190.  
  191.          return var2;
  192.       }
  193.    }
  194.  
  195.    Vector getSees(Vector var1, ClassDeclaration var2) {
  196.       Vector var3 = null;
  197.       Enumeration var4 = var1.elements();
  198.  
  199.       while(var4.hasMoreElements()) {
  200.          String var5 = (String)var4.nextElement();
  201.          if (var5.startsWith("@see")) {
  202.             var5 = var5.substring(4).trim();
  203.             if (var5.length() == 0) {
  204.                System.out.println("warning: empty @see statement.");
  205.             } else {
  206.                if (var3 == null) {
  207.                   var3 = new Vector();
  208.                }
  209.  
  210.                this.parseSeeString(var5, var2, var3);
  211.             }
  212.          }
  213.       }
  214.  
  215.       return var3;
  216.    }
  217.  
  218.    String getAuthors(Vector var1) {
  219.       if (!Main.showAuthors) {
  220.          return null;
  221.       } else {
  222.          String var2 = null;
  223.          Enumeration var3 = var1.elements();
  224.  
  225.          while(var3.hasMoreElements()) {
  226.             String var4 = (String)var3.nextElement();
  227.             if (var4.startsWith("@author")) {
  228.                var4 = var4.substring(7).trim();
  229.                if (var4.length() == 0) {
  230.                   System.out.println("warning: empty @author statement.");
  231.                } else if (var2 == null) {
  232.                   var2 = this.authorString(var4);
  233.                } else {
  234.                   var2 = var2 + ", " + this.authorString(var4);
  235.                }
  236.             }
  237.          }
  238.  
  239.          return var2;
  240.       }
  241.    }
  242.  
  243.    static Vector getParameters(Vector var0) {
  244.       Vector var1 = null;
  245.       Enumeration var2 = var0.elements();
  246.  
  247.       while(var2.hasMoreElements()) {
  248.          String var3 = (String)var2.nextElement();
  249.          if (var3.startsWith("@param")) {
  250.             int var4 = 0;
  251.  
  252.             for(var3 = var3.substring(6).trim(); var4 < var3.length() && var3.charAt(var4) != ' ' && var3.charAt(var4) != '\t'; ++var4) {
  253.             }
  254.  
  255.             if (var4 < var3.length()) {
  256.                if (var1 == null) {
  257.                   var1 = new Vector();
  258.                }
  259.  
  260.                var1.addElement(var3.substring(0, var4));
  261.                var1.addElement(var3.substring(var4).trim());
  262.             } else {
  263.                System.out.println("warning: empty @param statement.");
  264.             }
  265.          }
  266.       }
  267.  
  268.       return var1;
  269.    }
  270.  
  271.    Vector getThrows(Vector var1, FieldDefinition var2) {
  272.       Vector var3 = new Vector();
  273.       Enumeration var4 = var1.elements();
  274.  
  275.       while(var4.hasMoreElements()) {
  276.          String var5 = (String)var4.nextElement();
  277.          if (var5.startsWith("@exception")) {
  278.             int var6 = 0;
  279.  
  280.             for(var5 = var5.substring(10).trim(); var6 < var5.length() && var5.charAt(var6) != ' ' && var5.charAt(var6) != '\t'; ++var6) {
  281.             }
  282.  
  283.             if (var6 >= var5.length()) {
  284.                System.out.println("warning: empty @exception statement.");
  285.             } else {
  286.                Identifier var7 = Identifier.lookup(var5.substring(0, var6));
  287.  
  288.                ClassDeclaration var8;
  289.                try {
  290.                   var8 = this.env.getClassDeclaration(((SourceClass)var2.getClassDefinition()).getImports().resolve(this.env, var7));
  291.                } catch (ClassNotFound var14) {
  292.                   var8 = this.env.getClassDeclaration(var7);
  293.                }
  294.  
  295.                var3.addElement(var8);
  296.                var3.addElement(var5.substring(var6).trim());
  297.             }
  298.          }
  299.       }
  300.  
  301.       ClassDeclaration var18 = this.env.getClassDeclaration(Constants.idJavaLangError);
  302.       ClassDeclaration var19 = this.env.getClassDeclaration(Constants.idJavaLangRuntimeException);
  303.       ClassDeclaration var20 = this.env.getClassDeclaration(idIOException);
  304.       ClassDeclaration[] var21 = var2.getExceptions(this.env);
  305.  
  306.       label98:
  307.       for(int var9 = 0; var9 < var21.length; ++var9) {
  308.          ClassDeclaration var10 = var21[var9];
  309.  
  310.          try {
  311.             ClassDefinition var11 = var10.getClassDefinition(this.env);
  312.             if (!var11.subClassOf(this.env, var18) && !var11.subClassOf(this.env, var19) && !var11.subClassOf(this.env, var20)) {
  313.                for(int var12 = 0; var12 < var3.size(); var12 += 2) {
  314.                   if (var11.subClassOf(this.env, (ClassDeclaration)var3.elementAt(var12))) {
  315.                      continue label98;
  316.                   }
  317.                }
  318.  
  319.                System.out.println("Method " + var2 + " declares that it throws " + var11 + " but there is no documentation");
  320.             }
  321.          } catch (ClassNotFound var16) {
  322.             System.out.println("Couldn't find " + var16.name);
  323.          }
  324.       }
  325.  
  326.       label79:
  327.       for(int var22 = 0; var22 < var3.size(); var22 += 2) {
  328.          ClassDeclaration var23 = (ClassDeclaration)var3.elementAt(var22);
  329.  
  330.          try {
  331.             ClassDefinition var24 = var23.getClassDefinition(this.env);
  332.             if (!var24.subClassOf(this.env, var18) && !var24.subClassOf(this.env, var19) && !var24.subClassOf(this.env, var20)) {
  333.                for(int var13 = 0; var13 < var21.length; ++var13) {
  334.                   if (var24.subClassOf(this.env, var21[var13])) {
  335.                      continue label79;
  336.                   }
  337.                }
  338.  
  339.                System.out.println("Method " + var2 + " documents that it throws " + var23 + " but there is no declaration");
  340.             }
  341.          } catch (ClassNotFound var15) {
  342.             System.out.println("Couldn't find " + var15.name);
  343.          }
  344.       }
  345.  
  346.       if (var3.size() == 0) {
  347.          return null;
  348.       } else {
  349.          return var3;
  350.       }
  351.    }
  352.  
  353.    FieldDefinition getOverride(FieldDefinition var1) {
  354.       FieldDefinition var2 = null;
  355.  
  356.       try {
  357.          if (!var1.isStatic() && !var1.isConstructor() && var1.getClassDefinition().getSuperClass() != null) {
  358.             var2 = var1.getClassDefinition().getSuperClass().getClassDefinition(this.env).findMethod(this.env, var1.getName(), var1.getType());
  359.          }
  360.       } catch (ClassNotFound var3) {
  361.          var2 = null;
  362.       }
  363.  
  364.       return var2;
  365.    }
  366.  
  367.    boolean isException(ClassDeclaration var1) {
  368.       if (exDecl == null) {
  369.          Identifier var2 = Identifier.lookup("java.lang.Exception");
  370.          exDecl = this.env.getClassDeclaration(var2);
  371.       }
  372.  
  373.       try {
  374.          return var1.getClassDefinition(this.env).subClassOf(this.env, exDecl);
  375.       } catch (ClassNotFound var3) {
  376.          System.err.println("Warning: Couldn't find class info for " + exDecl.getName());
  377.          return false;
  378.       }
  379.    }
  380.  
  381.    boolean isError(ClassDeclaration var1) {
  382.       if (errorDecl == null) {
  383.          Identifier var2 = Identifier.lookup("java.lang.Error");
  384.          errorDecl = this.env.getClassDeclaration(var2);
  385.       }
  386.  
  387.       try {
  388.          return var1.getClassDefinition(this.env).subClassOf(this.env, errorDecl);
  389.       } catch (ClassNotFound var3) {
  390.          System.err.println("Warning: Couldn't find class info for " + errorDecl.getName());
  391.          return false;
  392.       }
  393.    }
  394.  
  395.    static PrintStream openFile(String var0) {
  396.       if (Main.destDir != null) {
  397.          var0 = Main.destDir.getPath() + File.separator + var0;
  398.       }
  399.  
  400.       FileOutputStream var1;
  401.       try {
  402.          var1 = new FileOutputStream(var0);
  403.       } catch (IOException var3) {
  404.          try {
  405.             (new File((new File(var0)).getParent())).mkdirs();
  406.             var1 = new FileOutputStream(var0);
  407.          } catch (IOException var2) {
  408.             throw new Error("Can't open output file");
  409.          }
  410.       }
  411.  
  412.       return new PrintStream(new BufferedOutputStream(var1));
  413.    }
  414.  
  415.    String firstSentence(ClassDefinition var1) {
  416.       return this.firstSentence(var1.getDocumentation());
  417.    }
  418.  
  419.    String firstSentence(FieldDefinition var1) {
  420.       return this.firstSentence(this.getDocumentation(var1));
  421.    }
  422.  
  423.    private String firstSentence(String var1) {
  424.       if (var1 == null) {
  425.          return "";
  426.       } else {
  427.          int var2 = var1.length();
  428.          boolean var3 = false;
  429.  
  430.          for(int var4 = 0; var4 < var2; ++var4) {
  431.             switch (var1.charAt(var4)) {
  432.                case '\t':
  433.                case '\n':
  434.                case ' ':
  435.                   if (var3) {
  436.                      return var1.substring(0, var4);
  437.                   }
  438.                   break;
  439.                case '.':
  440.                   var3 = true;
  441.                   break;
  442.                case '@':
  443.                   return var1.substring(0, var4);
  444.                default:
  445.                   var3 = false;
  446.             }
  447.          }
  448.  
  449.          return var1;
  450.       }
  451.    }
  452.  
  453.    String getDocumentation(FieldDefinition var1) {
  454.       String var2 = var1.getDocumentation();
  455.       if (var2 == null && !var1.isVariable() && !var1.isConstructor()) {
  456.          while(var1 != null && var2 == null) {
  457.             ClassDeclaration var3 = var1.getClassDefinition().getSuperClass();
  458.             if (var3 == null) {
  459.                break;
  460.             }
  461.  
  462.             try {
  463.                var1 = var3.getClassDefinition(this.env).findMethod(this.env, var1.getName(), var1.getType());
  464.             } catch (ClassNotFound var4) {
  465.                System.err.println("Warning: Couldn't find class info for " + var3.getName());
  466.                var1 = null;
  467.             }
  468.  
  469.             if (var1 != null) {
  470.                var2 = var1.getDocumentation();
  471.             }
  472.          }
  473.  
  474.          return var2 != null ? this.firstSentence(var2) : null;
  475.       } else {
  476.          return var2;
  477.       }
  478.    }
  479.  
  480.    String typeString(Type var1) {
  481.       switch (var1.getTypeCode()) {
  482.          case 0:
  483.             return "boolean";
  484.          case 1:
  485.             return "byte";
  486.          case 2:
  487.             return "char";
  488.          case 3:
  489.             return "short";
  490.          case 4:
  491.             return "int";
  492.          case 5:
  493.             return "long";
  494.          case 6:
  495.             return "float";
  496.          case 7:
  497.             return "double";
  498.          case 8:
  499.          default:
  500.             return "error";
  501.          case 9:
  502.             return this.typeString(var1.getElementType());
  503.          case 10:
  504.             return this.classString(this.env.getClassDeclaration(var1));
  505.          case 11:
  506.             return "void";
  507.       }
  508.    }
  509.  
  510.    String typeArrayString(Type var1) {
  511.       String var2;
  512.       for(var2 = ""; var1.getTypeCode() == 9; var1 = var1.getElementType()) {
  513.          var2 = var2 + "[]";
  514.       }
  515.  
  516.       return var2;
  517.    }
  518.  
  519.    static String modString(FieldDefinition var0) {
  520.       String var1;
  521.       if (var0.isPublic()) {
  522.          var1 = "  public";
  523.       } else if (var0.isProtected()) {
  524.          var1 = "  protected";
  525.       } else if (var0.isPrivate()) {
  526.          var1 = "  private";
  527.       } else {
  528.          var1 = "";
  529.       }
  530.  
  531.       if (var0.isFinal()) {
  532.          var1 = var1 + (var1.length() > 0 ? " final" : "final");
  533.       }
  534.  
  535.       if (var0.isStatic()) {
  536.          var1 = var1 + (var1.length() > 0 ? " static" : "static");
  537.       }
  538.  
  539.       if (var0.isSynchronized()) {
  540.          var1 = var1 + (var1.length() > 0 ? " synchronized" : "synchronized");
  541.       }
  542.  
  543.       if (var0.isAbstract()) {
  544.          var1 = var1 + (var1.length() > 0 ? " abstract" : "abstract");
  545.       }
  546.  
  547.       if (var0.isVolatile()) {
  548.          var1 = var1 + (var1.length() > 0 ? " volatile" : "volatile");
  549.       }
  550.  
  551.       if (var0.isTransient()) {
  552.          var1 = var1 + (var1.length() > 0 ? " transient" : "transient");
  553.       }
  554.  
  555.       return var1;
  556.    }
  557.  
  558.    private static int compare(ClassDeclaration var0, ClassDeclaration var1) {
  559.       Identifier var2 = var0.getName();
  560.       Identifier var3 = var1.getName();
  561.       int var4 = var2.getName().toString().compareTo(var3.getName().toString());
  562.       return var4 == 0 ? var2.getQualifier().toString().compareTo(var3.getQualifier().toString()) : var4;
  563.    }
  564.  
  565.    static void sort(ClassDeclaration[] var0) {
  566.       boolean var1;
  567.       do {
  568.          var1 = true;
  569.  
  570.          for(int var2 = var0.length - 1; var2 > 0; --var2) {
  571.             if (compare(var0[var2 - 1], var0[var2]) > 0) {
  572.                ClassDeclaration var3 = var0[var2];
  573.                var0[var2] = var0[var2 - 1];
  574.                var0[var2 - 1] = var3;
  575.                var1 = false;
  576.             }
  577.          }
  578.       } while(!var1);
  579.  
  580.    }
  581.  
  582.    void genPackagesDocumentation(Vector var1) {
  583.       Vector var2 = new Vector();
  584.       Vector var3 = new Vector();
  585.       Enumeration var4 = var1.elements();
  586.  
  587.       while(var4.hasMoreElements()) {
  588.          String var5 = (String)var4.nextElement();
  589.          (var5.startsWith("java.") ? var2 : var3).addElement(var5);
  590.       }
  591.  
  592.       String[] var7 = null;
  593.       String[] var6 = null;
  594.       if (var2.size() > 0) {
  595.          var7 = new String[var2.size()];
  596.          var2.copyInto(var7);
  597.          sort(var7);
  598.       }
  599.  
  600.       if (var3.size() > 0) {
  601.          var6 = new String[var3.size()];
  602.          var3.copyInto(var6);
  603.          sort(var6);
  604.       }
  605.  
  606.       this.genPackagesDocumentation(var7, var6);
  607.    }
  608.  
  609.    abstract void genPackagesDocumentation(String[] var1, String[] var2);
  610.  
  611.    void genPackageDocumentation(Identifier var1) {
  612.       int var2 = 0;
  613.       int var3 = 0;
  614.       int var4 = 0;
  615.       int var5 = 0;
  616.  
  617.       boolean var6;
  618.       do {
  619.          var6 = false;
  620.          Enumeration var7 = this.env.getClasses();
  621.  
  622.          while(var7.hasMoreElements()) {
  623.             ClassDeclaration var8 = (ClassDeclaration)var7.nextElement();
  624.             if (!var8.isDefined()) {
  625.                try {
  626.                   var8.getClassDefinition(this.env);
  627.                   var6 = true;
  628.                } catch (ClassNotFound var15) {
  629.                }
  630.             }
  631.          }
  632.       } while(var6);
  633.  
  634.       Enumeration var16 = this.env.getClasses();
  635.  
  636.       while(var16.hasMoreElements()) {
  637.          ClassDeclaration var17 = (ClassDeclaration)var16.nextElement();
  638.  
  639.          try {
  640.             ClassDefinition var19 = var17.getClassDefinition(this.env);
  641.             if (shouldDocument(var19) && var17.getName().getQualifier().equals(var1)) {
  642.                if (var17.getClassDefinition(this.env).isInterface()) {
  643.                   ++var2;
  644.                } else if (this.isException(var17)) {
  645.                   ++var4;
  646.                } else if (this.isError(var17)) {
  647.                   ++var5;
  648.                } else {
  649.                   ++var3;
  650.                }
  651.             }
  652.          } catch (ClassNotFound var14) {
  653.          }
  654.       }
  655.  
  656.       ClassDeclaration[] var18 = new ClassDeclaration[var2];
  657.       ClassDeclaration[] var20 = new ClassDeclaration[var3];
  658.       ClassDeclaration[] var9 = new ClassDeclaration[var4];
  659.       ClassDeclaration[] var10 = new ClassDeclaration[var5];
  660.       Enumeration var11 = this.env.getClasses();
  661.  
  662.       while(var11.hasMoreElements()) {
  663.          ClassDeclaration var12 = (ClassDeclaration)var11.nextElement();
  664.  
  665.          try {
  666.             if (shouldDocument(var12.getClassDefinition(this.env)) && var12.getName().getQualifier().equals(var1)) {
  667.                if (var12.getClassDefinition(this.env).isInterface()) {
  668.                   --var2;
  669.                   var18[var2] = var12;
  670.                } else if (this.isException(var12)) {
  671.                   --var4;
  672.                   var9[var4] = var12;
  673.                } else if (this.isError(var12)) {
  674.                   --var5;
  675.                   var10[var5] = var12;
  676.                } else {
  677.                   --var3;
  678.                   var20[var3] = var12;
  679.                }
  680.             }
  681.          } catch (ClassNotFound var13) {
  682.          }
  683.       }
  684.  
  685.       this.genPackageDocumentation(var1, var18, var20, var9, var10);
  686.    }
  687.  
  688.    abstract void genPackageDocumentation(Identifier var1, ClassDeclaration[] var2, ClassDeclaration[] var3, ClassDeclaration[] var4, ClassDeclaration[] var5);
  689.  
  690.    abstract void genClassDocumentation(ClassDefinition var1, ClassDeclaration var2, ClassDeclaration var3);
  691.  
  692.    abstract String classString(ClassDeclaration var1);
  693.  
  694.    static void sort(FieldDefinition[] var0) {
  695.       xsort(var0);
  696.    }
  697.  
  698.    static void sort(String[] var0) {
  699.       boolean var1;
  700.       do {
  701.          var1 = true;
  702.  
  703.          for(int var2 = var0.length - 1; var2 > 0; --var2) {
  704.             if (var0[var2 - 1].compareTo(var0[var2]) > 0) {
  705.                String var3 = var0[var2];
  706.                var0[var2] = var0[var2 - 1];
  707.                var0[var2 - 1] = var3;
  708.                var1 = false;
  709.             }
  710.          }
  711.       } while(!var1);
  712.  
  713.    }
  714.  
  715.    static String sortKey(FieldDefinition var0) {
  716.       ClassDefinition var1 = var0.getClassDefinition();
  717.       String var2 = (var1.getName().getName() + "." + var1.getName().getQualifier()).toLowerCase();
  718.       if (var0.isVariable()) {
  719.          return var0.getName().toString().toLowerCase() + " " + var2;
  720.       } else {
  721.          Identifier var3 = var0.isConstructor() ? var0.getClassDeclaration().getName().getName() : var0.getName();
  722.          Type var4 = var0.getType();
  723.          return var4.typeString(var3.toString(), true, false).toLowerCase() + var2;
  724.       }
  725.    }
  726.  
  727.    static void xsort(FieldDefinition[] var0, String[] var1) {
  728.       xsort(var0, var1, 0, var0.length - 1);
  729.    }
  730.  
  731.    static void xsort(FieldDefinition[] var0) {
  732.       String[] var1 = new String[var0.length];
  733.       int var2 = var0.length;
  734.  
  735.       while(true) {
  736.          --var2;
  737.          if (var2 < 0) {
  738.             xsort(var0, var1, 0, var0.length - 1);
  739.             return;
  740.          }
  741.  
  742.          var1[var2] = sortKey(var0[var2]);
  743.       }
  744.    }
  745.  
  746.    private static void xsort(FieldDefinition[] var0, String[] var1, int var2, int var3) {
  747.       if (var2 < var3) {
  748.          String var4 = var1[var2];
  749.          int var5 = var2;
  750.          int var6 = var3;
  751.  
  752.          while(var5 < var6) {
  753.             while(var5 <= var3 && var1[var5].compareTo(var4) <= 0) {
  754.                ++var5;
  755.             }
  756.  
  757.             while(var6 >= var2 && var1[var6].compareTo(var4) > 0) {
  758.                --var6;
  759.             }
  760.  
  761.             if (var5 < var6) {
  762.                FieldDefinition var7 = var0[var5];
  763.                String var8 = var1[var5];
  764.                var0[var5] = var0[var6];
  765.                var0[var6] = var7;
  766.                var1[var5] = var1[var6];
  767.                var1[var6] = var8;
  768.             }
  769.          }
  770.  
  771.          FieldDefinition var10 = var0[var2];
  772.          String var9 = var1[var2];
  773.          var0[var2] = var0[var6];
  774.          var0[var6] = var10;
  775.          var1[var2] = var1[var6];
  776.          var1[var6] = var9;
  777.          xsort(var0, var1, var2, var6 - 1);
  778.          xsort(var0, var1, var6 + 1, var3);
  779.       }
  780.    }
  781.  
  782.    Hashtable createClassTree() {
  783.       Hashtable var1 = new Hashtable();
  784.       Enumeration var2 = this.env.getClasses();
  785.  
  786.       while(var2.hasMoreElements()) {
  787.          ClassDeclaration var3 = (ClassDeclaration)var2.nextElement();
  788.  
  789.          try {
  790.             if (shouldDocument(var3.getClassDefinition(this.env))) {
  791.                this.genClassTree(var3, var1);
  792.             }
  793.          } catch (ClassNotFound var7) {
  794.          }
  795.       }
  796.  
  797.       Enumeration var8 = var1.keys();
  798.  
  799.       while(var8.hasMoreElements()) {
  800.          ClassDeclaration var4 = (ClassDeclaration)var8.nextElement();
  801.          Vector var5 = (Vector)var1.get(var4);
  802.          if (var5.size() > 0) {
  803.             ClassDeclaration[] var6 = new ClassDeclaration[var5.size()];
  804.             var5.copyInto(var6);
  805.             sort(var6);
  806.             var1.put(var4, var6);
  807.          } else {
  808.             var1.remove(var4);
  809.          }
  810.       }
  811.  
  812.       return var1;
  813.    }
  814.  
  815.    private Vector genClassTree(ClassDeclaration var1, Hashtable var2) {
  816.       Vector var3 = (Vector)var2.get(var1);
  817.       if (var3 != null) {
  818.          return var3;
  819.       } else {
  820.          var3 = new Vector();
  821.          var2.put(var1, var3);
  822.  
  823.          try {
  824.             ClassDeclaration var4 = var1.getClassDefinition(this.env).getSuperClass();
  825.             if (var4 != null) {
  826.                Vector var5 = this.genClassTree(var4, var2);
  827.                var5.addElement(var1);
  828.             }
  829.          } catch (ClassNotFound var6) {
  830.          }
  831.  
  832.          return var3;
  833.       }
  834.    }
  835.  
  836.    abstract void genFieldIndex();
  837.  
  838.    void genClassTree() {
  839.       this.genClassTree(this.createClassTree(), this.env.getClassDeclaration(Type.tObject.getClassName()));
  840.    }
  841.  
  842.    abstract void genClassTree(Hashtable var1, ClassDeclaration var2);
  843.  
  844.    void parseSeeString(String var1, ClassDeclaration var2, Vector var3) {
  845.       var1 = var1.trim();
  846.       int var6 = var1.indexOf(35);
  847.       String var5;
  848.       if (var6 >= 0) {
  849.          var5 = var1.substring(var6 + 1);
  850.          var1 = var1.substring(0, var6);
  851.       } else {
  852.          var5 = null;
  853.       }
  854.  
  855.       ClassDeclaration var4;
  856.       if (var1.length() > 0) {
  857.          try {
  858.             Identifier var7 = Identifier.lookup(var1);
  859.             SourceClass var8 = (SourceClass)var2.getClassDefinition(this.env);
  860.             Identifier var9 = var8.getImports().resolve(this.env, var7);
  861.             var4 = this.env.getClassDeclaration(var9);
  862.          } catch (ClassNotFound var11) {
  863.             var4 = this.env.getClassDeclaration(Identifier.lookup(var1));
  864.          }
  865.       } else {
  866.          var4 = var2;
  867.       }
  868.  
  869.       if (var5 == null) {
  870.          var3.addElement(var4);
  871.          var3.addElement((Object)null);
  872.          var3.addElement((Object)null);
  873.       } else {
  874.          var6 = var5.indexOf(40);
  875.          String var14 = var6 >= 0 ? var5.substring(0, var6) : var5;
  876.          Identifier var15 = Identifier.lookup(var14);
  877.  
  878.          try {
  879.             FieldDefinition var16 = var4.getClassDefinition(this.env).findAnyMethod(this.env, var15);
  880.             if (var16 == null) {
  881.                System.out.println("@see warning:  Can't find " + var14 + " in " + var4);
  882.             } else if (var16.getClassDeclaration() != var4) {
  883.                System.out.println("@see warning:  Found " + var14 + " in parent" + var16.getClassDeclaration() + " but not " + var4);
  884.                var4 = var16.getClassDeclaration();
  885.             }
  886.          } catch (ClassNotFound var10) {
  887.             System.out.println("@see warning:  Can't find class " + var4.getName());
  888.          }
  889.  
  890.          var3.addElement(var4);
  891.          var3.addElement(var14);
  892.          var3.addElement(var5);
  893.       }
  894.    }
  895. }
  896.